Attribution de coûts¶

Création des balises¶

Dans le cadre de la conception de la stratégie, décidez de la base de données et du schéma dans lesquels vous prévoyez de créer les balises.

• Vous pouvez créer une base de données et un schéma dédiés aux balises.

• Si vous souhaitez baliser des ressources dans différents comptes de votre organisation, vous pouvez créer les balises dans un compte clé de votre organisation (par exemple, dans le compte de votre organisation).

L’exemple suivant crée une base de données nommée cost_management et un schéma nommé tags pour les balises que vous planifiez d’utiliser :

USE ROLE tag_admin;

CREATE DATABASE cost_management;
CREATE SCHEMA tags;

Avec cost_management et tags sélectionnés comme base de données et schéma actuels, créez une balise nommée cost_center et définissez les valeurs autorisées pour la balise comme étant les noms des centres de coûts :

CREATE TAG cost_center
  ALLOWED_VALUES 'finance', 'marketing', 'engineering', 'product';

Réplication de la base de données des balises¶

Si vous avez une organisation avec plusieurs comptes et que vous voulez rendre les balises disponibles dans ces autres comptes, configurez vos comptes pour la réplication, et créez un groupe de réplication dans un compte principal (par exemple, dans le compte de l’organisation). Paramétrez ce groupe de réplication pour répliquer la base de données contenant les balises.

Par exemple, pour répliquer les balises sur les comptes my_org.my_account et my_org.my_account_2, exécutez cette instruction dans votre compte d’organisation :

CREATE REPLICATION GROUP cost_management_repl_group
  OBJECT_TYPES = DATABASES
  ALLOWED_DATABASES = cost_management
  ALLOWED_ACCOUNTS = my_org.my_account_1, my_org.my_account_2
  REPLICATION_SCHEDULE = '10 MINUTE';

Ensuite, dans chaque compte dans lequel vous souhaitez rendre les balises disponibles, créez un groupe de réplication secondaire et actualisez ce groupe à partir du groupe principal :

CREATE REPLICATION GROUP cost_management_repl_group
  AS REPLICA OF my_org.my_org_account.cost_management_repl_group;

ALTER REPLICATION GROUP cost_management_repl_group REFRESH;

Balise des ressources et des utilisateurs¶

Après avoir créé et répliqué les balises, vous pouvez utiliser ces dernières pour identifier les entrepôts et les utilisateurs appartenant à chaque département. Par exemple, comme le service des ventes utilise à la fois warehouse1 et warehouse2, vous pouvez attribuer à la balise cost_center la valeur 'SALES' pour les deux entrepôts.

USE ROLE tag_admin;

ALTER WAREHOUSE warehouse1 SET TAG cost_management.tags.cost_center='SALES';
ALTER WAREHOUSE warehouse2 SET TAG cost_management.tags.cost_center='SALES';
ALTER WAREHOUSE warehouse3 SET TAG cost_management.tags.cost_center='FINANCE';

ALTER USER finance_user SET TAG cost_management.tags.cost_center='FINANCE';
ALTER USER sales_user SET TAG cost_management.tags.cost_center='SALES';

Automatisation des balises utilisateur avec SCIM¶

Si vous souhaitez automatiser le processus de balisage des utilisateurs pour l’attribution des coûts, vous pouvez le faire en provisionnant les utilisateurs Snowflake via un fournisseur d’identité SCIM tel que Microsoft Entra ID ou Okta. Avec SCIM, vous pouvez automatiquement appliquer des balises d’attribution de coûts aux utilisateurs lors de leur création ou de leur mise à jour, ce qui élimine la nécessité d’exécuter``ALTER USER <user_name> SET TAG`` manuellement pour chaque nouvel utilisateur et garantit la cohérence de vos balises d’attribution des coûts lorsque des utilisateurs rejoignent l’entreprise ou changent de département.

Lorsque de l’utilisation du SCIM, l’attribut personnalisé snowflakeTags accepte une liste de références de balises entièrement qualifiées séparées par des virgules. Par exemple, pour affecter un utilisateur au centre de coûts finance lors du provisionnement, incluez la valeur suivante dans la charge utile SCIM de l’utilisateur :

{
  "userName": "JSMITH",
  "displayName": "Jane Smith",
  "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User": {
    "snowflakeUserName": "JSMITH",
    "snowflakeTags": "[cost_management.tags.cost_center:finance]"
  }
}

Les balises définies via SCIM apparaissent dans les mêmes vues TAG_REFERENCES et fonctionnent avec des filtres de balises Snowsight (voir Vue du coût par balise en Snowsight), de sorte que vos requêtes d’attribution des coûts et vos tableaux de bord existants fonctionnent sans modifications.

Pour commencer avec cette approche, vous devez :

• Créer les balises dans Snowflake, comme décrit dans Création des balises ci-dessus.

• Accorder au rôle de provisionnement SCIM le privilège USAGE sur le schéma de balises et le privilège APPLY sur chaque balise.

Pour les étapes de configuration complètes, les privilèges prérequis et des exemples d’API, voir « Renseigner les balises Snowflake avec des intégrations SCIM dans :

• SCIM avec Microsoft Entra ID

• SCIM avec Okta

• SCIM avec un fournisseur d’identité personnalisé

Ressources non partagées par les départements¶

Supposons que vous souhaitiez attribuer les coûts par département et que chaque département utilise un ensemble d’entrepôts dédiés.

Si vous balisez les entrepôts avec une balise cost_center pour identifier le département propriétaire de l’entrepôt, vous pouvez joindre ACCOUNT_USAGE Vue TAG_REFERENCES à Vue WAREHOUSE_METERING_HISTORY sur les colonnes object_id et warehouse_id pour obtenir des informations sur l’utilisation par entrepôt, et vous pouvez utiliser la colonne tag_value pour identifier les départements propriétaires de ces entrepôts.

L’instruction SQL suivante permet d’effectuer cette jonction :

SELECT
    TAG_REFERENCES.tag_name,
    COALESCE(TAG_REFERENCES.tag_value, 'untagged') AS tag_value,
    SUM(WAREHOUSE_METERING_HISTORY.credits_used_compute) AS total_credits
  FROM
    SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
      LEFT JOIN SNOWFLAKE.ACCOUNT_USAGE.TAG_REFERENCES
        ON WAREHOUSE_METERING_HISTORY.warehouse_id = TAG_REFERENCES.object_id
          AND TAG_REFERENCES.domain = 'WAREHOUSE'
  WHERE
    WAREHOUSE_METERING_HISTORY.start_time >= DATE_TRUNC('MONTH', DATEADD(MONTH, -1, CURRENT_DATE))
      AND WAREHOUSE_METERING_HISTORY.start_time < DATE_TRUNC('MONTH',  CURRENT_DATE)
  GROUP BY TAG_REFERENCES.tag_name, COALESCE(TAG_REFERENCES.tag_value, 'untagged')
  ORDER BY total_credits DESC;

+-------------+-------------+-----------------+
| TAG_NAME    | TAG_VALUE   |   TOTAL_CREDITS |
|-------------+-------------+-----------------|
| NULL        | untagged    |    20.360277159 |
| COST_CENTER | Sales       |    17.173333333 |
| COST_CENTER | Finance     |      8.14444444 |
+-------------+-------------+-----------------+

Vous pouvez exécuter une requête similaire pour effectuer le même attribut pour tous les comptes de votre organisation en utilisant les vues du schéma ORGANIZATION_USAGE à partir du compte de l’organisation. Le reste de la requête ne change pas.

SELECT
    TAG_REFERENCES.tag_name,
    COALESCE(TAG_REFERENCES.tag_value, 'untagged') AS tag_value,
    SUM(WAREHOUSE_METERING_HISTORY.credits_used_compute) AS total_credits
  FROM
    SNOWFLAKE.ORGANIZATION_USAGE.WAREHOUSE_METERING_HISTORY
      LEFT JOIN SNOWFLAKE.ORGANIZATION_USAGE.TAG_REFERENCES
        ON WAREHOUSE_METERING_HISTORY.warehouse_id = TAG_REFERENCES.object_id
          AND TAG_REFERENCES.domain = 'WAREHOUSE'
          AND tag_database = 'COST_MANAGEMENT' AND tag_schema = 'TAGS'
  WHERE
    WAREHOUSE_METERING_HISTORY.start_time >= DATE_TRUNC('MONTH', DATEADD(MONTH, -1, CURRENT_DATE))
      AND WAREHOUSE_METERING_HISTORY.start_time < DATE_TRUNC('MONTH',  CURRENT_DATE)
  GROUP BY TAG_REFERENCES.tag_name, COALESCE(TAG_REFERENCES.tag_value, 'untagged')
  ORDER BY total_credits DESC;

Ressources partagées par des utilisateurs de différents départements¶

Supposons que des utilisateurs de différents services partagent les mêmes entrepôts et que vous souhaitiez ventiler les crédits utilisés par chaque service. Vous pouvez étiqueter les utilisateurs avec une balise cost_center pour identifier le département auquel ils appartiennent, et vous pouvez joindre le Vue TAG_REFERENCES avec le Vue QUERY_ATTRIBUTION_HISTORY.

Les sections suivantes présentent des exemples d’instructions SQL pour l’attribution des coûts des ressources partagées.

• Calcul du coût des requêtes des utilisateurs pour le dernier mois

• Calcul du coût des requêtes des utilisateurs par département sans temps mort

• Calcul du coût des requêtes des utilisateurs sans temps mort

• Calcul du coût des requêtes effectuées par des utilisateurs sans balise

WITH
  wh_bill AS (
    SELECT SUM(credits_used_compute) AS compute_credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
      WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
        AND start_time < CURRENT_DATE
  ),
  user_credits AS (
    SELECT user_name, SUM(credits_attributed_compute) AS credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
      WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
        AND start_time < CURRENT_DATE
      GROUP BY user_name
  ),
  total_credit AS (
    SELECT SUM(credits) AS sum_all_credits
    FROM user_credits
  )
SELECT
    u.user_name,
    u.credits / t.sum_all_credits * w.compute_credits AS attributed_credits
  FROM user_credits u, total_credit t, wh_bill w
  ORDER BY attributed_credits DESC;

+-----------+--------------------+
| USER_NAME | ATTRIBUTED_CREDITS |
|-----------+--------------------+
| FINUSER   | 6.603575468        |
| SALESUSER | 4.321378049        |
| ENGUSER   | 0.6217131392       |
|-----------+--------------------+

WITH joined_data AS (
  SELECT
      tr.tag_name,
      tr.tag_value,
      qah.credits_attributed_compute,
      qah.start_time
    FROM SNOWFLAKE.ACCOUNT_USAGE.TAG_REFERENCES tr
      JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY qah
        ON tr.domain = 'USER' AND tr.object_name = qah.user_name
)
SELECT
    tag_name,
    tag_value,
    SUM(credits_attributed_compute) AS total_credits
  FROM joined_data
  WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
    AND start_time < CURRENT_DATE
  GROUP BY tag_name, tag_value
  ORDER BY tag_name, tag_value;

+-------------+-------------+-----------------+
| TAG_NAME    | TAG_VALUE   |   TOTAL_CREDITS |
|-------------+-------------+-----------------|
| COST_CENTER | engineering |   0.02493688426 |
| COST_CENTER | finance     |    0.2281084988 |
| COST_CENTER | marketing   |    0.3686840545 |
|-------------+-------------+-----------------|

SELECT user_name, SUM(credits_attributed_compute) AS credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE
    start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
    AND start_time < CURRENT_DATE
  GROUP BY user_name;

+-----------+--------------------+
| USER_NAME | ATTRIBUTED_CREDITS |
|-----------+--------------------|
| JSMITH    |       17.173333333 |
| MJONES    |         8.14444444 |
| SYSTEM    |         5.33985393 |
+-----------+--------------------+

SELECT qah.user_name, SUM(qah.credits_attributed_compute) as total_credits
  FROM
    SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY qah
    LEFT JOIN snowflake.account_usage.tag_references tr
    ON qah.user_name = tr.object_name AND tr.DOMAIN = 'USER'
  WHERE
    start_time >= dateadd(month, -1, current_date)
    AND qah.user_name IS NULL OR tr.object_name IS NULL
  GROUP BY qah.user_name
  ORDER BY total_credits DESC;

+------------+---------------+
| USER_NAME  | TOTAL_CREDITS |
|------------+---------------|
| RSMITH     |  0.1830555556 |
+------------+---------------+

Ressources utilisées par les applications qui doivent attribuer les coûts aux différents services¶

Les exemples de cette section calculent les coûts d’une ou plusieurs applications alimentées par Snowflake.

Les exemples supposent que ces applications établissent des paramètres de requête qui identifient l’application pour toutes les requêtes exécutées. Pour définir la balise de requête pour les requêtes d’une session, exécutez la commande ALTER SESSION. Par exemple :

ALTER SESSION SET QUERY_TAG = 'COST_CENTER=finance';

La balise COST_CENTER=finance est ainsi associée à toutes les requêtes ultérieures exécutées au cours de la session.

Vous pouvez ensuite utiliser la balise de requête pour tracer le coût de ces requêtes vers les services concernés.

Les sections suivantes présentent des exemples d’utilisation de cette approche.

• Calcul du coût des requêtes par département

• Calcul du coût des requêtes (à l’exclusion du temps d’inactivité) par balise de requête

• Calcul du coût des requêtes (y compris le temps d’inactivité) par balise de requête

SELECT
    query_tag,
    SUM(credits_attributed_compute) AS compute_credits,
    SUM(credits_used_query_acceleration) AS qas
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE query_tag = 'COST_CENTER=finance'
  GROUP BY query_tag;

+---------------------+-----------------+------+
| QUERY_TAG           | COMPUTE_CREDITS | QAS  |
|---------------------+-----------------|------|
| COST_CENTER=finance |      0.00576115 | null |
+---------------------+-----------------+------+

SELECT
    COALESCE(NULLIF(query_tag, ''), 'untagged') AS tag,
    SUM(credits_attributed_compute) AS compute_credits,
    SUM(credits_used_query_acceleration) AS qas
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
  GROUP BY tag
  ORDER BY compute_credits DESC;

+-------------------------+-----------------+------+
| TAG                     | COMPUTE_CREDITS | QAS  |
|-------------------------+-----------------+------+
| untagged                | 3.623173449     | null |
| COST_CENTER=engineering | 0.531431948     | null |
|-------------------------+-----------------+------+

WITH
  wh_bill AS (
    SELECT SUM(credits_used_compute) AS compute_credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
      WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
      AND start_time < CURRENT_DATE
  ),
  tag_credits AS (
    SELECT
        COALESCE(NULLIF(query_tag, ''), 'untagged') AS tag,
        SUM(credits_attributed_compute) AS credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
      WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
      GROUP BY tag
  ),
  total_credit AS (
    SELECT SUM(credits) AS sum_all_credits
      FROM tag_credits
  )
SELECT
    tc.tag,
    tc.credits / t.sum_all_credits * w.compute_credits AS attributed_credits
  FROM tag_credits tc, total_credit t, wh_bill w
  ORDER BY attributed_credits DESC;

+-------------------------+--------------------+
| TAG                     | ATTRIBUTED_CREDITS |
+-------------------------+--------------------|
| untagged                |        9.020031304 |
| COST_CENTER=finance     |        1.027742521 |
| COST_CENTER=engineering |        1.018755812 |
| COST_CENTER=marketing   |       0.4801370376 |
+-------------------------+--------------------+

Groupement de requêtes similaires¶

Pour les requêtes récurrentes ou similaires, utilisez query_hash ou query_parameterized_hash pour regrouper les coûts par requête.

Pour trouver les requêtes récurrentes les plus coûteuses pour le mois en cours, exécutez l’instruction suivante :

SELECT query_parameterized_hash,
       COUNT(*) AS query_count,
       SUM(credits_attributed_compute) AS total_credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
  AND start_time < CURRENT_DATE
  GROUP BY query_parameterized_hash
  ORDER BY total_credits DESC
  LIMIT 20;

Pour une requête supplémentaire basée sur l’ID de requête, voir Exemples.

Attribution des coûts des requêtes hiérarchiques¶

Pour les procédures stockées qui émettent plusieurs requêtes hiérarchiques, vous pouvez calculer les coûts de requête attribués à la procédure en utilisant l’ID de requête racine pour la procédure.

1. Pour trouver l’ID de requête racine pour une procédure stockée, utilisez Vue ACCESS_HISTORY. Par exemple, pour trouver l’ID de requête racine pour une procédure stockée, définissez query_id et exécutez les instructions suivantes :

   CopyExpand

   SET query_id = '<query_id>';
   
   SELECT query_id,
          parent_query_id,
          root_query_id,
          direct_objects_accessed
     FROM SNOWFLAKE.ACCOUNT_USAGE.ACCESS_HISTORY
     WHERE query_id = $query_id;
   

   Show lessSee more

   Scroll to top

   Pour plus d’informations, voir Requêtes ancêtres à l’aide de procédures stockées.

2. Pour additionner les coûts de la requête pour l’ensemble de la procédure, remplacez <root_query_id> et exécutez les instructions suivantes :

   CopyExpand

   SET query_id = '<root_query_id>';
   
   SELECT SUM(credits_attributed_compute) AS total_attributed_credits
     FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
     WHERE (root_query_id = $query_id OR query_id = $query_id);
   

   Show lessSee more

   Scroll to top